{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "!apt-get install cmake\n",
    "!apt-get install zlib1g-dev\n",
    "!pip install gym[atari]\n",
    "!pip install JSAnimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/root/miniconda3/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n",
      "  return f(*args, **kwds)\n",
      "Using TensorFlow backend.\n",
      "/root/miniconda3/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n",
      "  return f(*args, **kwds)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# import cPickle as pickle\n",
    "import matplotlib.pyplot as plt\n",
    "from JSAnimation.IPython_display import display_animation\n",
    "from matplotlib import animation\n",
    "import gym\n",
    "\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Conv2D, MaxPool2D, Flatten\n",
    "from keras.optimizers import adam\n",
    "import keras.backend as K\n",
    "\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n",
      "[4, 2]\n"
     ]
    }
   ],
   "source": [
    "env = gym.make('CartPole-v0')\n",
    "STATES, ACTIONS = env.observation_space.shape[0], env.action_space.n\n",
    "print([STATES, ACTIONS])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_frames_as_gif(frames):\n",
    "    \"\"\"\n",
    "    Displays a list of frames as a gif, with controls\n",
    "    \"\"\"\n",
    "    #plt.figure(figsize=(frames[0].shape[1] / 72.0, frames[0].shape[0] / 72.0), dpi = 72)\n",
    "    patch = plt.imshow(frames[0])\n",
    "    plt.axis('off')\n",
    "\n",
    "    def animate(i):\n",
    "        patch.set_data(frames[i])\n",
    "\n",
    "    anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=50)\n",
    "    display(display_animation(anim, default_mode='once'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgZTQOEMBERUUUYDOR\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderZTQOEMBERUUUYDOR\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animZTQOEMBERUUUYDOR.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animZTQOEMBERUUUYDOR.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animZTQOEMBERUUUYDOR.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZTQOEMBERUUUYDOR.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZTQOEMBERUUUYDOR.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZTQOEMBERUUUYDOR.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZTQOEMBERUUUYDOR.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZTQOEMBERUUUYDOR.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZTQOEMBERUUUYDOR.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZTQOEMBERUUUYDOR.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectZTQOEMBERUUUYDOR\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" checked> Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" > Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgZTQOEMBERUUUYDOR\";\n",
       "    var slider_id = \"_anim_sliderZTQOEMBERUUUYDOR\";\n",
       "    var loop_select_id = \"_anim_loop_selectZTQOEMBERUUUYDOR\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animZTQOEMBERUUUYDOR = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n"
     ]
    }
   ],
   "source": [
    "observation = env.reset()\n",
    "cum_reward = 0\n",
    "frames = []\n",
    "r = []\n",
    "for t in range(100):\n",
    "    # Render into buffer. \n",
    "    frames.append(env.render(mode = 'rgb_array'))\n",
    "    a = np.random.choice(ACTIONS)\n",
    "    observation, reward, done, info = env.step(a)\n",
    "    r.append(reward)\n",
    "    if done:\n",
    "        break\n",
    "        \n",
    "r = np.array(r)\n",
    "# env.render(close=True)\n",
    "display_frames_as_gif(frames)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "gamma = 0.99\n",
    "def discount_rewards(rewards):\n",
    "    \"\"\" take 1D float array of rewards and compute discounted reward \"\"\"\n",
    "    discounted_r = np.zeros_like(rewards)\n",
    "    running_add = 0\n",
    "    for t in reversed(range(len(discounted_r))):\n",
    "        running_add =  rewards[t] + running_add * gamma # belman equation\n",
    "        discounted_r[t] = running_add\n",
    "    return discounted_r\n",
    "\n",
    "def discount_n_standardise(rewards):\n",
    "    dr = discount_rewards(rewards)\n",
    "    dr = (dr - dr.mean()) / dr.std()\n",
    "    return dr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reinforcement Learning\n",
    "\n",
    "It turns out that action 2 makes the racket go up and 3 makes the racket go down. It has 6 actions by default because it's an Atari game, and there were 6 buttons in the controller. See [here](https://ai.stackexchange.com/questions/2449/what-are-different-actions-in-action-space-of-environment-of-pong-v0-game-from) for source of this answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def policy_loss(adv_y_true, y_pred):\n",
    "    reward = adv_y_true[:,0]\n",
    "    y_true = adv_y_true[:,1:]\n",
    "#     from IPython.core.debugger import Tracer; Tracer()()\n",
    "    return K.sum(reward*\n",
    "                  K.sparse_categorical_crossentropy(y_true, y_pred), \n",
    "                  axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_7 (Dense)              (None, 16)                80        \n",
      "_________________________________________________________________\n",
      "dense_8 (Dense)              (None, 16)                272       \n",
      "_________________________________________________________________\n",
      "dense_9 (Dense)              (None, 2)                 34        \n",
      "=================================================================\n",
      "Total params: 386\n",
      "Trainable params: 386\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()\n",
    "model.add(Dense(16, input_dim=STATES, activation='relu'))\n",
    "model.add(Dense(16, input_dim=STATES, activation='relu'))\n",
    "model.add(Dense(ACTIONS, activation='softmax'))\n",
    "model.compile(optimizer=adam(), loss=policy_loss) #\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode: 50, Average Loss: -0.2003, Average Reward: 26.5500, Average steps: 25.5500\n",
      "Episode: 100, Average Loss: -0.5610, Average Reward: 30.9000, Average steps: 29.9000\n",
      "Episode: 150, Average Loss: -0.9267, Average Reward: 52.5000, Average steps: 51.5000\n",
      "Episode: 200, Average Loss: -2.5208, Average Reward: 81.7000, Average steps: 80.7000\n",
      "Episode: 250, Average Loss: -2.2739, Average Reward: 118.3500, Average steps: 117.3500\n",
      "Episode: 300, Average Loss: -2.6553, Average Reward: 143.0000, Average steps: 142.0000\n",
      "Episode: 350, Average Loss: -2.1165, Average Reward: 181.1000, Average steps: 180.1000\n",
      "Episode: 400, Average Loss: -1.5926, Average Reward: 188.1500, Average steps: 187.1500\n",
      "Episode: 450, Average Loss: -3.3651, Average Reward: 188.9000, Average steps: 187.9000\n",
      "Episode: 500, Average Loss: -0.9923, Average Reward: 187.0000, Average steps: 186.0000\n",
      "Episode: 550, Average Loss: -1.0628, Average Reward: 192.2000, Average steps: 191.2000\n",
      "Episode: 600, Average Loss: -2.5196, Average Reward: 184.8500, Average steps: 183.8500\n",
      "Episode: 650, Average Loss: -2.3156, Average Reward: 193.7000, Average steps: 192.7000\n",
      "Episode: 700, Average Loss: -1.7747, Average Reward: 193.5000, Average steps: 192.5000\n",
      "Episode: 750, Average Loss: -3.5115, Average Reward: 193.0000, Average steps: 192.0000\n",
      "Episode: 800, Average Loss: -2.2478, Average Reward: 196.2500, Average steps: 195.2500\n",
      "Solved!\n"
     ]
    }
   ],
   "source": [
    "episodes = 0\n",
    "n_episodes = 1000\n",
    "reward_sums = np.zeros(n_episodes)\n",
    "losses = np.zeros(n_episodes)\n",
    "time_taken = np.zeros(n_episodes)\n",
    "reward_sum = 0\n",
    "prev_x = None\n",
    "im_shape = (80, 80, 1)\n",
    "\n",
    "buffer = 500\n",
    "xs = np.zeros((buffer, STATES))\n",
    "ys = np.zeros((buffer,1))\n",
    "rs = np.zeros((buffer,1))\n",
    "\n",
    "k = 0\n",
    "\n",
    "observation = env.reset()\n",
    "\n",
    "while episodes<n_episodes:\n",
    "    xs[k] = observation\n",
    "    p = model.predict(observation[None,:])\n",
    "#     from IPython.core.debugger import Tracer; Tracer()()\n",
    "    a = np.random.choice(ACTIONS, p=p[0])\n",
    "    ys[k] = a\n",
    "    \n",
    "    observation, reward, done, info = env.step(a)\n",
    "    reward_sum += reward\n",
    "    rs[k] = reward\n",
    "    \n",
    "    k += 1\n",
    "    \n",
    "    if done or k==buffer:\n",
    "        k = np.where(rs[:k]!=0)[0][-1]\n",
    "        reward_sums[episodes] = reward_sum\n",
    "        reward_sum = 0\n",
    "        \n",
    "        \n",
    "        ep_x = xs[:k]\n",
    "        ep_y = ys[:k]\n",
    "        ep_r = rs[:k]\n",
    "        \n",
    "        ep_r = discount_n_standardise(ep_r)\n",
    "        model.fit(ep_x, np.hstack([ep_r, ep_y]), batch_size=512, epochs=1, verbose=0)\n",
    "        \n",
    "        time_taken[episodes] = k\n",
    "        k = 0\n",
    "        observation = env.reset()\n",
    "        losses[episodes] = model.evaluate(ep_x, \n",
    "                                          np.hstack([ep_r, ep_y]), \n",
    "                                          batch_size=len(ep_x), \n",
    "                                          verbose=0)\n",
    "        episodes += 1\n",
    "        \n",
    "        if episodes%(n_episodes//20) == 0:\n",
    "            ave_reward = np.mean(reward_sums[max(0,episodes-20):episodes])\n",
    "            ave_loss = np.mean(losses[max(0,episodes-20):episodes])\n",
    "            ave_time = np.mean(time_taken[max(0,episodes-20):episodes])\n",
    "            print('Episode: {0:d}, Average Loss: {1:.4f}, Average Reward: {2:.4f}, Average steps: {3:.4f}'\n",
    "                  .format(episodes, ave_loss, ave_reward, ave_time))\n",
    "            if ave_reward > 195:\n",
    "                print('Solved!')\n",
    "                break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "window = 20\n",
    "plt.plot(losses[:episodes])\n",
    "plt.plot(np.convolve(losses[:episodes], np.ones((window,))/window, mode='valid'))\n",
    "plt.title('Loss')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(reward_sums[:episodes])\n",
    "plt.plot(np.convolve(reward_sums[:episodes], np.ones((window,))/window, mode='valid'))\n",
    "plt.title('Total Score')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgEDGANGYHIHYNFSOP\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderEDGANGYHIHYNFSOP\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animEDGANGYHIHYNFSOP.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animEDGANGYHIHYNFSOP.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animEDGANGYHIHYNFSOP.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animEDGANGYHIHYNFSOP.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animEDGANGYHIHYNFSOP.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animEDGANGYHIHYNFSOP.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animEDGANGYHIHYNFSOP.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animEDGANGYHIHYNFSOP.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animEDGANGYHIHYNFSOP.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animEDGANGYHIHYNFSOP.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectEDGANGYHIHYNFSOP\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" checked> Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" > Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgEDGANGYHIHYNFSOP\";\n",
       "    var slider_id = \"_anim_sliderEDGANGYHIHYNFSOP\";\n",
       "    var loop_select_id = \"_anim_loop_selectEDGANGYHIHYNFSOP\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animEDGANGYHIHYNFSOP = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99\n"
     ]
    }
   ],
   "source": [
    "observation = env.reset()\n",
    "cum_reward = 0\n",
    "frames = []\n",
    "r = []\n",
    "for t in range(100):\n",
    "    # Render into buffer. \n",
    "    frames.append(env.render(mode = 'rgb_array'))\n",
    "    p = model.predict(observation[None,:])\n",
    "    a = np.random.choice(ACTIONS,p=p.squeeze())\n",
    "    observation, reward, done, info = env.step(a)\n",
    "    r.append(reward)\n",
    "    if done:\n",
    "        break\n",
    "        \n",
    "r = np.array(r)\n",
    "# env.render(close=True)\n",
    "display_frames_as_gif(frames)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
